home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / bit / src / mpeg / util.h < prev    next >
C/C++ Source or Header  |  1994-08-01  |  22KB  |  368 lines
  1. /*
  2.  * Copyright (c) 1992 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Permission to use, copy, modify, and distribute this software and its
  6.  * documentation for any purpose, without fee, and without written agreement is
  7.  * hereby granted, provided that the above copyright notice and the following
  8.  * two paragraphs appear in all copies of this software.
  9.  * 
  10.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  11.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  12.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  13.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  * 
  15.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  16.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  18.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  19.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  20.  */
  21.  
  22. /* Status codes for bit stream i/o operations. */
  23.  
  24. #ifndef UTIL_H_
  25. #define UTIL_H_
  26.  
  27. #define NO_VID_STREAM -1
  28. #define UNDERFLOW -2
  29. #define OK 1
  30.  
  31. /* Size increment of extension data buffers. */
  32.  
  33. #define EXT_BUF_SIZE 1024
  34.  
  35. /* External declarations for bitstream i/o operations. */
  36. extern unsigned int bitMask[];
  37. extern unsigned int nBitMask[];
  38. extern unsigned int rBitMask[];
  39. extern unsigned int bitTest[];
  40.  
  41. /* External declarations of bitstream global variables. */
  42. extern unsigned int curBits;
  43. extern int bitOffset;
  44. extern int bufLength;
  45. extern unsigned int *bitBuffer;
  46.  
  47. /* Macro for updating bit counter if analysis tool is on. */
  48. #ifdef ANALYSIS
  49. #define UPDATE_COUNT(numbits) bitCount += numbits
  50. #else
  51. #define UPDATE_COUNT(numbits)
  52. #endif
  53.  
  54. #ifdef NO_SANITY_CHECKS
  55. #define get_bits1(result)                                                 \
  56. {                                                                         \
  57.   UPDATE_COUNT(1);                                                        \
  58.   result = ((curBits & 0x80000000) != 0);                              \
  59.   curBits <<= 1;                                                          \
  60.   bitOffset++;                                                            \
  61.                                                                           \
  62.   if (bitOffset & 0x20) {                                                 \
  63.     bitOffset = 0;                                                        \
  64.     bitBuffer++;                                                          \
  65.     curBits = *bitBuffer;                                                 \
  66.     bufLength--;                                                          \
  67.   }                                                                       \
  68. }
  69.  
  70. #define get_bits2(result)                                                 \
  71. {                                                                         \
  72.   UPDATE_COUNT(2);                                                        \
  73.   bitOffset += 2;                                                         \
  74.                                                                           \
  75.   if (bitOffset & 0x20) {                                                 \
  76.     bitOffset -= 32;                                                      \
  77.     bitBuffer++;                                                          \
  78.     bufLength--;                                                          \
  79.     if (bitOffset) {                                                      \
  80.       curBits |= (*bitBuffer >> (2 - bitOffset));                         \
  81.     }                                                                     \
  82.     result = ((curBits & 0xc0000000) >> 30);                           \
  83.     curBits = *bitBuffer << bitOffset;                                    \
  84.   }                                                                       \
  85.                                                                           \
  86.   result = ((curBits & 0xc0000000) >> 30);                             \
  87.   curBits <<= 2;                                                          \
  88. }
  89.  
  90. #define get_bitsX(num, mask, shift,  result)                              \
  91. {                                                                         \
  92.   UPDATE_COUNT(num);                                                      \
  93.   bitOffset += num;                                                       \
  94.                                                                           \
  95.   if (bitOffset & 0x20) {                                                 \
  96.     bitOffset -= 32;                                                      \
  97.     bitBuffer++;                                                          \
  98.     bufLength--;                                                          \
  99.     if (bitOffset) {                                                      \
  100.       curBits |= (*bitBuffer >> (num - bitOffset));                       \
  101.     }                                                                     \
  102.     result = ((curBits & mask) >> shift);                              \
  103.     curBits = *bitBuffer << bitOffset;                                    \
  104.   }                                                                       \
  105.   else {                                                                  \
  106.     result = ((curBits & mask) >> shift);                              \
  107.     curBits <<= num;                                                      \
  108.   }                                                                       \
  109. }
  110. #else
  111.  
  112. #define get_bits1(result)                                                 \
  113. {                                                                         \
  114.   /* Check for underflow. */                                              \
  115.                                                                           \
  116.   if (bufLength < 2) {                                                    \
  117.     correct_underflow();                                                  \
  118.   }                                                                       \
  119.   UPDATE_COUNT(1);                                                        \
  120.   result = ((curBits & 0x80000000) != 0);                              \
  121.   curBits <<= 1;                                                          \
  122.   bitOffset++;                                                            \
  123.                                                                           \
  124.   if (bitOffset & 0x20) {                                                 \
  125.     bitOffset = 0;                                                        \
  126.     bitBuffer++;                                                          \
  127.     curBits = *bitBuffer;                                                 \
  128.     bufLength--;                                                          \
  129.   }                                                                       \
  130. }
  131.  
  132. #define get_bits2(result)                                                 \
  133. {                                                                         \
  134.   /* Check for underflow. */                                              \
  135.                                                                           \
  136.   if (bufLength < 2) {                                                    \
  137.     correct_underflow();                                                  \
  138.   }                                                                       \
  139.   UPDATE_COUNT(2);                                                        \
  140.   bitOffset += 2;                                                         \
  141.                                                                           \
  142.   if (bitOffset & 0x20) {                                                 \
  143.     bitOffset -= 32;                                                      \
  144.     bitBuffer++;                                                          \
  145.     bufLength--;                                                          \
  146.     if (bitOffset) {                                                      \
  147.       curBits |= (*bitBuffer >> (2 - bitOffset));                         \
  148.     }                                                                     \
  149.     result = ((curBits & 0xc0000000) >> 30);                           \
  150.     curBits = *bitBuffer << bitOffset;                                    \
  151.   }                                                                       \
  152.                                                                           \
  153.   result = ((curBits & 0xc0000000) >> 30);                             \
  154.   curBits <<= 2;                                                          \
  155. }
  156.  
  157. #define get_bitsX(num, mask, shift,  result)                              \
  158. {                                                                         \
  159.   /* Check for underflow. */                                              \
  160.                                                                           \
  161.   if (bufLength < 2) {                                                    \
  162.     correct_underflow();                                                  \
  163.   }                                                                       \
  164.   UPDATE_COUNT(num);                                                      \
  165.   bitOffset += num;                                                       \
  166.                                                                           \
  167.   if (bitOffset & 0x20) {                                                 \
  168.     bitOffset -= 32;                                                      \
  169.     bitBuffer++;                                                          \
  170.     bufLength--;                                                          \
  171.     if (bitOffset) {                                                      \
  172.       curBits |= (*bitBuffer >> (num - bitOffset));                       \
  173.     }                                                                     \
  174.     result = ((curBits & mask) >> shift);                              \
  175.     curBits = *bitBuffer << bitOffset;                                    \
  176.   }                                                                       \
  177.   else {                                                                  \
  178.    result = ((curBits & mask) >> shift);                               \
  179.    curBits <<= num;                                                       \
  180.   }                                                                       \
  181. }
  182. #endif
  183.  
  184. #define get_bits3(result) get_bitsX(3,   0xe0000000, 29, result)
  185. #define get_bits4(result) get_bitsX(4,   0xf0000000, 28, result)
  186. #define get_bits5(result) get_bitsX(5,   0xf8000000, 27, result)
  187. #define get_bits6(result) get_bitsX(6,   0xfc000000, 26, result)
  188. #define get_bits7(result) get_bitsX(7,   0xfe000000, 25, result)
  189. #define get_bits8(result) get_bitsX(8,   0xff000000, 24, result)
  190. #define get_bits9(result) get_bitsX(9,   0xff800000, 23, result)
  191. #define get_bits10(result) get_bitsX(10, 0xffc00000, 22, result)
  192. #define get_bits11(result) get_bitsX(11, 0xffe00000, 21, result)
  193. #define get_bits12(result) get_bitsX(12, 0xfff00000, 20, result)
  194. #define get_bits14(result) get_bitsX(14, 0xfffc0000, 18, result)
  195. #define get_bits16(result) get_bitsX(16, 0xffff0000, 16, result)
  196. #define get_bits18(result) get_bitsX(18, 0xffffc000, 14, result)
  197. #define get_bits32(result) get_bitsX(32, 0xffffffff,  0, result)
  198.  
  199. #define get_bitsn(num, result) get_bitsX((num), nBitMask[num], (32-(num)), result)
  200.  
  201. #ifdef NO_SANITY_CHECKS
  202. #define show_bits32(result)                                      \
  203. {                                                                       \
  204.   if (bitOffset) {                            \
  205.     result = curBits | (*(bitBuffer+1) >> (32 - bitOffset));        \
  206.   }                                                                     \
  207.   else {                                                                \
  208.     result = curBits;                            \
  209.   }                                                                     \
  210. }
  211.  
  212. #define show_bitsX(num, mask, shift,  result)                           \
  213. {                                                                       \
  214.   int bO;                                                               \
  215.   bO = bitOffset + num;                                                 \
  216.   if (bO > 32) {                                                        \
  217.     bO -= 32;                                                           \
  218.     result = ((curBits & mask) >> shift) |                              \
  219.                 (*(bitBuffer+1) >> (shift + (num - bO)));               \
  220.   }                                                                     \
  221.   else {                                                                \
  222.     result = ((curBits & mask) >> shift);                               \
  223.   }                                                                     \
  224. }
  225.  
  226. #else
  227. #define show_bits32(result)                                       \
  228. {                                                                       \
  229.   /* Check for underflow. */                                            \
  230.   if (bufLength < 2) {                                                  \
  231.     correct_underflow();                                                \
  232.   }                                                                     \
  233.   if (bitOffset) {                            \
  234.     result = curBits | (*(bitBuffer+1) >> (32 - bitOffset));        \
  235.   }                                                                     \
  236.   else {                                                                \
  237.     result = curBits;                            \
  238.   }                                                                     \
  239. }
  240.  
  241. #define show_bitsX(num, mask, shift, result)                            \
  242. {                                                                       \
  243.   int bO;                                                               \
  244.                                                                         \
  245.   /* Check for underflow. */                                            \
  246.   if (bufLength < 2) {                                                  \
  247.     correct_underflow();                                                \
  248.   }                                                                     \
  249.   bO = bitOffset + num;                                                 \
  250.   if (bO > 32) {                                                        \
  251.     bO -= 32;                                                           \
  252.     result = ((curBits & mask) >> shift) |                              \
  253.                 (*(bitBuffer+1) >> (shift + (num - bO)));               \
  254.   }                                                                     \
  255.   else {                                                                \
  256.     result = ((curBits & mask) >> shift);                               \
  257.   }                                                                     \
  258. }
  259. #endif
  260.  
  261. #define show_bits1(result)  show_bitsX(1,  0x80000000, 31, result)
  262. #define show_bits2(result)  show_bitsX(2,  0xc0000000, 30, result)
  263. #define show_bits3(result)  show_bitsX(3,  0xe0000000, 29, result)
  264. #define show_bits4(result)  show_bitsX(4,  0xf0000000, 28, result)
  265. #define show_bits5(result)  show_bitsX(5,  0xf8000000, 27, result)
  266. #define show_bits6(result)  show_bitsX(6,  0xfc000000, 26, result)
  267. #define show_bits7(result)  show_bitsX(7,  0xfe000000, 25, result)
  268. #define show_bits8(result)  show_bitsX(8,  0xff000000, 24, result)
  269. #define show_bits9(result)  show_bitsX(9,  0xff800000, 23, result)
  270. #define show_bits10(result) show_bitsX(10, 0xffc00000, 22, result)
  271. #define show_bits11(result) show_bitsX(11, 0xffe00000, 21, result)
  272. #define show_bits12(result) show_bitsX(12, 0xfff00000, 20, result)
  273. #define show_bits13(result) show_bitsX(13, 0xfff80000, 19, result)
  274. #define show_bits14(result) show_bitsX(14, 0xfffc0000, 18, result)
  275. #define show_bits15(result) show_bitsX(15, 0xfffe0000, 17, result)
  276. #define show_bits16(result) show_bitsX(16, 0xffff0000, 16, result)
  277. #define show_bits17(result) show_bitsX(17, 0xffff8000, 15, result)
  278. #define show_bits18(result) show_bitsX(18, 0xffffc000, 14, result)
  279. #define show_bits19(result) show_bitsX(19, 0xffffe000, 13, result)
  280. #define show_bits20(result) show_bitsX(20, 0xfffff000, 12, result)
  281. #define show_bits21(result) show_bitsX(21, 0xfffff800, 11, result)
  282. #define show_bits22(result) show_bitsX(22, 0xfffffc00, 10, result)
  283. #define show_bits23(result) show_bitsX(23, 0xfffffe00,  9, result)
  284. #define show_bits24(result) show_bitsX(24, 0xffffff00,  8, result)
  285. #define show_bits25(result) show_bitsX(25, 0xffffff80,  7, result)
  286. #define show_bits26(result) show_bitsX(26, 0xffffffc0,  6, result)
  287. #define show_bits27(result) show_bitsX(27, 0xffffffe0,  5, result)
  288. #define show_bits28(result) show_bitsX(28, 0xfffffff0,  4, result)
  289. #define show_bits29(result) show_bitsX(29, 0xfffffff8,  3, result)
  290. #define show_bits30(result) show_bitsX(30, 0xfffffffc,  2, result)
  291. #define show_bits31(result) show_bitsX(31, 0xfffffffe,  1, result)
  292.  
  293. #define show_bitsn(num,result) show_bitsX((num), (0xffffffff << (32-(num))), (32-(num)), result)
  294.  
  295. #ifdef NO_SANITY_CHECKS
  296. #define flush_bits32                                                  \
  297. {                                                                     \
  298.   UPDATE_COUNT(32);                                                   \
  299.                                                                       \
  300.   bitBuffer++;                                                        \
  301.   bufLength--;                                                        \
  302.   curBits = *bitBuffer  << bitOffset;                                 \
  303. }
  304.  
  305. #define flush_bits(num)                                               \
  306. {                                                                     \
  307.   bitOffset += num;                                                   \
  308.                                                                       \
  309.   UPDATE_COUNT(num);                                                  \
  310.                                                                       \
  311.   if (bitOffset & 0x20) {                                             \
  312.     bitOffset -= 32;                                                  \
  313.     bitBuffer++;                                                      \
  314.     bufLength--;                                                      \
  315.     curBits = *bitBuffer  << bitOffset;                               \
  316.   }                                                                   \
  317.   else {                                                              \
  318.     curBits <<= num;                                                  \
  319.   }                                                                   \
  320. }
  321. #else
  322. #define flush_bits32                                                  \
  323. {                                                                     \
  324.   if (curVidStream == NULL) {                                         \
  325.     /* Deal with no vid stream here. */                               \
  326.   }                                                                   \
  327.                                                                       \
  328.   if (bufLength < 2) {                                                \
  329.     correct_underflow();                                              \
  330.   }                                                                   \
  331.                                                                       \
  332.   UPDATE_COUNT(32);                                                   \
  333.                                                                       \
  334.   bitBuffer++;                                                        \
  335.   bufLength--;                                                        \
  336.   curBits = *bitBuffer  << bitOffset;                                 \
  337. }
  338.  
  339. #define flush_bits(num)                                               \
  340. {                                                                     \
  341.   if (curVidStream == NULL) {                                         \
  342.     /* Deal with no vid stream here. */                               \
  343.   }                                                                   \
  344.                                                                       \
  345.   if (bufLength < 2) {                                                \
  346.     correct_underflow();                                              \
  347.   }                                                                   \
  348.                                                                       \
  349.   UPDATE_COUNT(num);                                                  \
  350.                                                                       \
  351.   bitOffset += num;                                                   \
  352.                                                                       \
  353.   if (bitOffset & 0x20) {                                             \
  354.     bufLength--;                                                      \
  355.     bitOffset -= 32;                                                  \
  356.     bitBuffer++;                                                      \
  357.     curBits = *bitBuffer << bitOffset;                                \
  358.   }                                                                   \
  359.   else {                                                              \
  360.     curBits <<= num;                                                  \
  361.   }                                                                   \
  362. }
  363. #endif
  364.  
  365. #define UTIL2
  366.  
  367. #endif
  368.